BCI NET/BCI NET Dec 94.iso/archives/programming/utilities/easyproc2.lha/EasyProcess/dragon/Dragon.c

C/C++ Source or Header | 1992-11-05 | 5.6 KB | 329 lines

#include "Dragon.h"
#include "DragonGad.h"
#include "source:launch/launch.h"

struct Window *DragonWin, *InputWin;
struct Screen *Screen;
struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;

static char FileName[128];

void main (void)
{
    struct IntuiMessage *Message;
    struct Gadget *Gadget;
    LONG Class;
    WORD StartX, StartY;
    struct Dragon Drag, *NewDrag;

    SetUp ();

    CopyMem (DragonWin->RPort, &Drag.RastPort, sizeof (struct RastPort));
    Drag.DuplicateCount = 0;
    Drag.KindCount = 0;

    while (1)
    {
        WaitPort (InputWin->UserPort);

        while ( (Message = (struct IntuiMessage *)GetMsg (InputWin->UserPort)) != NULL)
        {
            Class = Message->Class;
            Gadget = (struct Gadget *)Message->IAddress;
            ReplyMsg (Message);

            if (Class == CLOSEWINDOW)
            {
                CleanUp ();
            }

            if (Class == GADGETUP)
            {
                switch (Gadget->GadgetID)
                {
                    case DAYGAD:
                    {
                        Drag.Day = ReadNumber (DayGadSIBuff, NULL);
                        ActivateGadget (&XGad, InputWin, 0);
                        break;
                    }

                    case CELLGAD:
                    {
                        Drag.Cell = ReadNumber (CellGadSIBuff, NULL);
                        ActivateGadget (&NameGad, InputWin, 0);
                        break;
                    }

                    case XGAD:
                    {
                        StartX = ReadNumber (XGadSIBuff, NULL);
                        ActivateGadget (&YGad, InputWin, 0);
                        break;
                    }

                    case YGAD:
                    {
                        StartY = ReadNumber (YGadSIBuff, NULL);
                        ActivateGadget (&CellGad, InputWin, 0);
                        break;
                    }

                    case LOADGAD:
                    {
                        if (Load (&Drag) != 0)
                        {
                            Drag.DuplicateCount = 0;
                            Drag.KindCount = 0;
                        }
                        ActivateGadget (&DayGad, InputWin, 0);
                        break;
                    }

                    case GOGAD:
                    {
                        Drag.DragonX = StartX;
                        Drag.DragonY = StartY;
                        NewDrag = AllocMem (sizeof (struct Dragon), 0L);
                        if (NewDrag)
                        {
                            CopyMem (&Drag, NewDrag, sizeof (struct Dragon));
                            if (NULL == StartProcess ("Dragon generator", MakeDragon, NewDrag, -1))
                            {
                                DisplayBeep (Screen);
                                FreeMem (NewDrag, sizeof (struct Dragon));
                            }
                        }
                        ActivateGadget (&DayGad, InputWin, 0);
                        break;
                    }

                    case STOPGAD:
                    {
                        KillProcesses ();
                        WaitProcesses ();
                        ActivateGadget (&DayGad, InputWin, 0);
                        break;
                    }

                    case CLEARGAD:
                    {
                        SetAPen (&Drag.RastPort, 0);
                        RectFill (&Drag.RastPort, 0, 0, 640, 399);
                        SetAPen (&Drag.RastPort, 1);
                        ActivateGadget (&DayGad, InputWin, 0);
                        break;
                    }

                    case NAMEGAD:
                    {
                        strcpy (FileName, NameGadSIBuff);
                        ActivateGadget (&DayGad, InputWin, 0);
                        break;
                    }
                }
            }
        }
    }
}


void MakeDragon (struct Dragon *Drag)
{
    Move (&Drag->RastPort, Drag->DragonX, Drag->DragonY);
    Dragon (Drag->Day, Drag->Cell, Drag);
    FreeMem (Drag, sizeof (struct Dragon));
}


void Dragon (WORD Day, WORD Cell, struct Dragon *Drag)
{
    WORD i;

    if (CheckKill ())
    {
        return;
    }

    if (Day <= 0)
    {
        Drag->DragonX += Drag->MoveX[Cell];
        Drag->DragonY += Drag->MoveY[Cell];
        Draw (&Drag->RastPort, Drag->DragonX, Drag->DragonY);
    }
    else
    {
        for (i = 0; i < Drag->DuplicateCount; i++)
        {
            Dragon (Day-1, Drag->Duplicate[Cell][i], Drag);
        }
    }
}


WORD ReadNumber (BYTE *Buffer, WORD *PosPtr)
{
    WORD Number, Sign, Position;

    Sign = 1;
    Position = 0;
    Number = 0;

    while (*Buffer == ' ' || *Buffer == 10)
    {
        Position++;
        Buffer++;
    }

    if (*Buffer == '-')
    {
        Sign = -1;
        Position++;
        Buffer++;
    }

    while (*Buffer >= '0' && *Buffer <= '9')
    {
        Number *= 10;
        Number += *Buffer - '0';
        Buffer++;
        Position++;
    }

    if (PosPtr != NULL)
    {
        *PosPtr += Position;
    }

    return (Sign == 1 ? Number : -Number);
}


extern void *DOSBase;

WORD Load (struct Dragon *Drag)
{
    LONG Len;
    WORD i,j;
    WORD Position;
    BYTE *Buffer;
    BPTR File;

    Buffer = NULL;

    {
        if ( (File = Open (FileName, MODE_OLDFILE)) == NULL)
            goto bad;

        Len = Seek (File, 0, OFFSET_END);
        Len = Seek (File, 0, OFFSET_BEGINNING);

        if ( (Buffer = AllocMem (Len, MEMF_CLEAR)) == NULL)
        {
            Close (File);
            goto bad;
        }

        Read (File, Buffer, Len);
        Close (File);

        Position = 0;

        Drag->KindCount = ReadNumber (Buffer+Position, &Position);
        Drag->DuplicateCount = ReadNumber (Buffer+Position, &Position);

        if (Drag->KindCount <= 0 || Drag->DuplicateCount <= 0)
            goto bad;

        for (i = 0; i < Drag->KindCount; i++)
        {
            Drag->MoveX[i] = ReadNumber (Buffer+Position, &Position);
        }

        for (i = 0; i < Drag->KindCount; i++)
        {
            Drag->MoveY[i] = ReadNumber (Buffer+Position, &Position);
        }

        for (i = 0; i < Drag->KindCount; i++)
        {
            for (j = 0; j < Drag->DuplicateCount; j++)
            {
                Drag->Duplicate[i][j] = ReadNumber (Buffer+Position, &Position);
                if (Drag->Duplicate[i][j] < 0)
                {
                    goto bad;
                }
            }
        }

        FreeMem (Buffer, Len);
        return 0;
    }

bad:
    if (Buffer)
        FreeMem (Buffer, Len);
    return 1;
}


void SetUp (void)
{
    if ( (GfxBase = (void *)OpenLibrary ("graphics.library", 0)) == NULL)
    {
        CleanUp ();
    }

    if ( (IntuitionBase = (void *)OpenLibrary ("intuition.library", 0)) == NULL)
    {
        CleanUp ();
    }

    if ( (Screen = OpenScreen(&DragonNewScreen)) == NULL )
    {
        CleanUp();
    }

    SetRGB4 (&Screen->ViewPort, 0, 0, 0, 0);
    SetRGB4 (&Screen->ViewPort, 1, 4, 6, 14);

    DragonNewWin.Screen = InputNewWin.Screen = Screen;

    if ( (DragonWin = OpenWindow (&DragonNewWin)) == NULL )
    {
        CleanUp ();
    }

    if ( (InputWin = OpenWindow (&InputNewWin)) == NULL )
    {
        CleanUp ();
    }

}


void CleanUp (void)
{
    KillProcesses ();
    WaitProcesses ();

    if (InputWin)
        CloseWindow (InputWin);

    if (DragonWin)
        CloseWindow (DragonWin);

    if (Screen)
        CloseScreen (Screen);

    if (IntuitionBase)
        CloseLibrary (IntuitionBase);

    if (GfxBase)
        CloseLibrary (GfxBase);

    exit (0);
}